package cn.itcast.tanhua.mytanhuaserver.service.impl;

import cn.itcast.tanhua.mytanhuaserver.mapper.*;
import cn.itcast.tanhua.mytanhuaserver.service.TestSoulService;
import cn.itcast.tanhua.pojo.*;
import cn.itcast.tanhua.utils.UserThreadLocal;
import cn.itcast.tanhua.vo.*;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: 杨雅雯
 * @Date: 2021/12/8 15:34
 */
@Service
public class TestSoulServiceImpl implements TestSoulService {


    //用户对应问卷锁表
    @Autowired
    private QuestionUserLockMapper questionUserLockMapper;

    //题目表
    @Autowired
    private SoulQuestionMapper soulQuestionMapper;

    //题目选项表
    @Autowired
    private SoulQuestionOptionMapper soulQuestionOptionMapper;

    //问卷表
    @Autowired
    private QuestionnaireMapper questionnaireMapper;


    //问卷结果表
    @Autowired
    private QuestionnaireResultMapper questionnaireResultMapper;

    //报告表
    @Autowired
    private QuestionnaireReportMapper questionnaireReportMapper;

    @Autowired
    private UserInfoMapper userInfoMapper;

    /**
     * 获取问卷列表
     *
     * @return
     */
    @Override
    public List<QuestionnaireVo> getQuestionnaire() {
        //获取用户
        User user = UserThreadLocal.get();
        //创建前端要的问卷列表对象[问卷列表VO]
        List<QuestionnaireVo> questionnaireVoList = new ArrayList<>();
        //通过用户id去QuestionUserLock找自己的答题情况
        QueryWrapper<QuestionUserLock> userLockQueryWrapper = new QueryWrapper<>();
        //把QuestionUserLock的user_id和该用户id进行匹配
        userLockQueryWrapper.eq("user_id", user.getId());
        //匹配成功，根据用户要去做哪套卷就去拿该问卷的id和锁的状态
        List<QuestionUserLock> questionUserLock = this.questionUserLockMapper.selectList(userLockQueryWrapper);
        for (QuestionUserLock questionUserLocks : questionUserLock) {
            //创建问卷列表VO
            QuestionnaireVo questionnaireVo = new QuestionnaireVo();
            //将问卷的id和锁的状态存入问卷列表VO
            questionnaireVo.setId(String.valueOf(questionUserLocks.getQuestionnaireId()));
            //questionnaireVo.setId(questionUserLocks.getQuestionnaireId());
            questionnaireVo.setIsLock(questionUserLocks.getIsLock());
            questionnaireVoList.add(questionnaireVo);
        }



        // 查出默认的三条大题型的数据
        QueryWrapper<Questionnaire> queryWrapper = new QueryWrapper<>();
        List<Questionnaire> questionnaireList = this.questionnaireMapper.selectList(queryWrapper);
        for (Questionnaire questionnaire : questionnaireList) {
            for (QuestionnaireVo questionnaireVo : questionnaireVoList) {
                //将用户选择的问卷id和题目表的id对比，如果相同，放入问卷列表VO
                if (questionnaire.getId().equals(questionnaireVo.getId())) {
                    questionnaireVo.setLevel(questionnaire.getLevel());
                    questionnaireVo.setName(questionnaire.getName());
                    questionnaireVo.setCover(questionnaire.getCover());
                    questionnaireVo.setStar(questionnaire.getStar());
                }

                // 通过当前的题型和userId查询对应的报告id
                QueryWrapper<QuestionnaireReport> queryWrapper1 = new QueryWrapper<>();
                queryWrapper1.eq("user_id",user.getId()).eq("questionnaire_id",questionnaireVo.getId());
                QuestionnaireReport questionnaireReport = this.questionnaireReportMapper.selectOne(queryWrapper1);
                if (questionnaireReport != null) {
                    questionnaireVo.setReportId(questionnaireReport.getId().toString());
                }
            }
        }

        //获取问卷id的集合（因为有多套问卷）,结果是：1、2、3
        List<Long> questionnaireIdList = new ArrayList<>();
        for (QuestionUserLock UserId : questionUserLock) {
            questionnaireIdList.add(UserId.getQuestionnaireId());
        }

        for (QuestionnaireVo questionnaireVo : questionnaireVoList) {
            //构建条件查询构建器，去查询测灵魂的题目内容
            QueryWrapper<SoulQuestions> soulQuestionsQueryWrapper = new QueryWrapper<>();
            //查找条件：问卷id相同
            soulQuestionsQueryWrapper.eq("questionnaire_id", questionnaireVo.getId());
            //获取题目表的数据
            List<SoulQuestions> soulQuestionsList = this.soulQuestionMapper.selectList(soulQuestionsQueryWrapper);
            //创建【题目VO】 前端显示的测灵魂-题目表-试题的出参
            List<Questions> questionsVo = new ArrayList<>();
            //补充questionsVo里面的数据
            for (SoulQuestions soulQuestions : soulQuestionsList) {
                Questions questions = new Questions();
                questions.setId(soulQuestions.getId().toString());
                questions.setQuestion(soulQuestions.getStem());
                //将题目选项存入集合
                //创建选项条件查询构建器
                QueryWrapper<SoulQuestionOption> soulQuestionOptionQueryWrapper = new QueryWrapper<>();
                //查询条件：题目编号id
                soulQuestionOptionQueryWrapper.eq("question_id", soulQuestions.getId());
                List<SoulQuestionOption> soulQuestionOptionList = this.soulQuestionOptionMapper.selectList(soulQuestionOptionQueryWrapper);
                List<Options> optionsList = new ArrayList<>();
                for (SoulQuestionOption soulQuestionOption : soulQuestionOptionList) {
                    Options options = new Options();
                    options.setId(soulQuestionOption.getId().toString());
                    options.setOption(soulQuestionOption.getOption());
                    optionsList.add(options);
                }
                questions.setOptions(optionsList);
                questionsVo.add(questions);
            }
            questionnaireVo.setQuestions(questionsVo);
        }
        return questionnaireVoList;
    }

    /**
     * 提交问卷
     *
     * @param answersList
     * @return
     */
    @Override
    public String SubmitQuestionnaire(List<Answers> answersList) {
        //设置初始值
        Integer score = 0;
        Long questionId = 0L;

        //获取提交的问卷的项目分数，进行统计
        for (Answers answers : answersList) {
            questionId = Long.valueOf(answers.getQuestionId());
            String optionId = answers.getOptionId();

            //创建条件查询构建器
            QueryWrapper queryWrapper = new QueryWrapper<>();
            //查询条件
            queryWrapper.eq("id", optionId);
            SoulQuestionOption soulQuestionOption = this.soulQuestionOptionMapper.selectOne(queryWrapper);
            score += Integer.parseInt(soulQuestionOption.getScore());
        }

//        System.out.println("灵魂测试题总分：" + score);

        //通过题目id查到对应的问卷id
        SoulQuestions soulQuestions = this.soulQuestionMapper.selectById(questionId);
        Long questionnaireId = soulQuestions.getQuestionnaireId();

        //因为每个用户都是没做过测灵魂的，所以默认一进去做题是初级测灵魂，所以初级灵魂题都为开锁状态
        //构建条件查询器
        QueryWrapper<QuestionUserLock> queryWrapper = new QueryWrapper<>();
        if (questionnaireId < 3) {
            queryWrapper.eq("questionnaire_id", questionnaireId + 1);
            QuestionUserLock questionUserLock = this.questionUserLockMapper.selectOne(queryWrapper);
            if (questionUserLock.getIsLock().equals(1)) {
                questionUserLock.setIsLock(0);
                this.questionUserLockMapper.update(questionUserLock, queryWrapper);
            }
        }
        //通过问卷id，查看结果表，看分数在哪个范围里面，然后开始判断用户所属的类型，然后把数据添加到报告表
        //创建条件查询构建器
        QueryWrapper<QuestionnaireResult> resultQueryWrapper = new QueryWrapper<>();
        resultQueryWrapper.eq("questionnaire_id", questionnaireId);
        List<QuestionnaireResult> questionnaireResults = this.questionnaireResultMapper.selectList(resultQueryWrapper);

        //创建问卷报告表
        QuestionnaireReport questionnaireReport = new QuestionnaireReport();
        //添加用户id
        questionnaireReport.setUserId(UserThreadLocal.get().getId());
        //添加问卷id
        questionnaireReport.setQuestionnaireId(questionnaireId);
        //遍历报告表
        for (QuestionnaireResult questionnaireResult : questionnaireResults) {
            //切割分数范围
            String[] split = questionnaireResult.getScope().split(",");
            if (score >= Integer.valueOf(split[0]) && score <= Integer.valueOf(split[1])) {
                questionnaireReport.setResultId(questionnaireResult.getId());
                break;
            }
        }

        User user = UserThreadLocal.get();
        QueryWrapper<QuestionnaireReport> queryWrapper2 = new QueryWrapper<>();
        queryWrapper2.eq("user_id",user.getId()).eq("questionnaire_id",questionnaireId);
        QuestionnaireReport questionnaireReport1 = this.questionnaireReportMapper.selectOne(queryWrapper2);
        if (questionnaireReport1 != null){
            questionnaireReport.setId(questionnaireReport1.getId());
            // 更新数据
            this.questionnaireReportMapper.updateById(questionnaireReport);
            return questionnaireReport1.getId().toString();
        }else {
            questionnaireReportMapper.insert(questionnaireReport);
        }
         questionnaireReportMapper.insert(questionnaireReport);
        QueryWrapper<QuestionnaireReport> queryWrapper3 = new QueryWrapper<>();
        queryWrapper3.eq("user_id",user.getId()).eq("questionnaire_id",questionnaireId);
        QuestionnaireReport questionnaireReport3 = this.questionnaireReportMapper.selectOne(queryWrapper2);
        return questionnaireReport3.getId().toString();
    }

    /**
     * 查看结果
     *
     * @param id 用户id
     * @return
     */
    @Override
    public UserReportVo UserResult(Long id) {
        //创建用户报告出参对象【结果VO】
        UserReportVo userReportVo=new UserReportVo();
        //创建维度集合
        List<Dimensions> dimensionsList=new ArrayList<>();

        //通过报告表id获取报告里面的数据
        QuestionnaireReport questionnaireReport = this.questionnaireReportMapper.selectById(id);
        Long resultId = questionnaireReport.getResultId();

        //通过报告表里面的resultId查询数据，写维度集合里
        QuestionnaireResult questionnaireResult = questionnaireResultMapper.selectById(resultId);
        dimensionsList.add(new Dimensions("extroversion",questionnaireResult.getExtroversion()));
        dimensionsList.add(new Dimensions("judgement",questionnaireResult.getJudgement()));
        dimensionsList.add(new Dimensions("abstraction",questionnaireResult.getAbstraction()));
        dimensionsList.add(new Dimensions("rationality",questionnaireResult.getRationality()));

        //然后将上面的数据存入【结果VO】
        userReportVo.setConclusion(questionnaireResult.getContent());
        userReportVo.setCover(questionnaireResult.getCover());
        userReportVo.setDimensions(dimensionsList);

        //要开始找【与你相似】的人了

        //通过结果id去查询报告表，获取所有的用户，存入集合里面
        //创建问卷报告条件查询构建器
        QueryWrapper<QuestionnaireReport> queryWrapper = new QueryWrapper();
        //查询条件
        queryWrapper.eq("result_id",resultId);
        List<QuestionnaireReport> questionnaireReports = questionnaireReportMapper.selectList(queryWrapper);
        List<Long> userIds = new ArrayList<>();
        for (QuestionnaireReport report : questionnaireReports) {
            userIds.add(report.getUserId());
        }


        //查询所有用户的完整信息
        QueryWrapper<UserInfo> userInfoQueryWrapper = new QueryWrapper();
        userInfoQueryWrapper.in("user_id",userIds);
        List<UserInfo> userInfos = userInfoMapper.selectList(userInfoQueryWrapper);

        //创建与你相似对象
        ArrayList<SimilarYou> similarYouList = new ArrayList<>();
        //进行判断，如果是当前用户就跳过，不是的话就添加到【与你相似】
        for (UserInfo userInfo : userInfos) {
            if(UserThreadLocal.get().getId().equals(userInfo.getUserId())){
                continue;
            }
            similarYouList.add(new SimilarYou(userInfo.getUserId(),userInfo.getLogo()));
        }
        userReportVo.setSimilarYou(similarYouList);
        return userReportVo;
    }
}
